AI助手Boer助力：一文读懂Spring AOP，从痛点剖析到动态代理，一篇打通面试关

@Service
public class UserService {
    
    public void createUser(String name, String email) {
        // ✅ 核心业务：创建用户
        userRepository.save(new User(name, email));
        
        // ❌ 横切关注点：日志记录
        System.out.println("【日志】用户创建成功: " + name);
        
        // ❌ 横切关注点：权限校验
        if (!SecurityContext.hasPermission("CREATE_USER")) {
            throw new AccessDeniedException();
        }
        
        // ❌ 横切关注点：性能监控
        long start = System.currentTimeMillis();
        // ... 业务逻辑
        System.out.println("【耗时】" + (System.currentTimeMillis() - start) + "ms");
    }
    
    public void updateUser(Long id, String name) {
        // ✅ 核心业务：更新用户
        userRepository.update(id, name);
        
        // ❌ 同样的一套日志、权限、监控代码，重复出现
        System.out.println("【日志】用户更新成功: " + id);
        if (!SecurityContext.hasPermission("UPDATE_USER")) {
            throw new AccessDeniedException();
        }
        long start = System.currentTimeMillis();
        // ...
        System.out.println("【耗时】" + (System.currentTimeMillis() - start) + "ms");
    }
}

@Service
public class UserService {
    
    @Log          // 自定义注解，由切面处理日志
    @CheckPermission("CREATE_USER")  // 由切面处理权限
    public void createUser(String name, String email) {
        // 只有核心业务：创建用户
        userRepository.save(new User(name, email));
    }
    
    // 其他方法同理...
}

@Aspect
@Component
public class LoggingAspect {
    
    // 1. 前置通知：目标方法执行前运行
    @Before("execution( com.example.service..(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        System.out.println("【前置】即将执行: " + joinPoint.getSignature().getName());
    }
    
    // 2. 后置通知：目标方法执行后运行（无论是否异常）
    @After("execution( com.example.service..(..))")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("【后置】方法执行完毕: " + joinPoint.getSignature().getName());
    }
    
    // 3. 返回通知：目标方法正常返回后运行（可获取返回值）
    @AfterReturning(pointcut = "execution( com.example.service..(..))", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【返回】返回值: " + result);
    }
    
    // 4. 异常通知：目标方法抛出异常后运行
    @AfterThrowing(pointcut = "execution( com.example.service..(..))", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("【异常】出错: " + ex.getMessage());
    }
    
    // 5. 环绕通知：最强大，可完全控制目标方法的执行
    @Around("execution( com.example.service..(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【环绕前】开始计时");
        
        Object result = joinPoint.proceed();  // 执行目标方法
        
        long cost = System.currentTimeMillis() - start;
        System.out.println("【环绕后】耗时: " + cost + "ms");
        return result;
    }
}

┌─────────────────────────────────────────────────────────────┐
│                    切面（Aspect）                            │
│  ┌─────────────────┐     ┌─────────────────────────────┐   │
│  │   切入点         │  +  │         通知                │   │
│  │   (Pointcut)    │     │         (Advice)            │   │
│  │  "拦截哪些方法"   │     │    "拦截后做什么"           │   │
│  └─────────────────┘     └─────────────────────────────┘   │
│                          ↓                                   │
│                   连接点（Join Point）                       │
│                 "程序执行中的每个可能时机"                    │
└─────────────────────────────────────────────────────────────┘

<!-- spring-boot-starter-aop 自动包含spring-aop和aspectjweaver -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

// 业务接口
public interface CalculatorService {
    int add(int a, int b);
    int div(int a, int b);
}

// 业务实现类（目标对象）
@Service("calculatorService")
public class CalculatorServiceImpl implements CalculatorService {
    @Override
    public int add(int a, int b) {
        int result = a + b;
        System.out.println("【业务】加法结果: " + result);
        return result;
    }
    
    @Override
    public int div(int a, int b) {
        int result = a / b;
        System.out.println("【业务】除法结果: " + result);
        return result;
    }
}

@Aspect          // 标注为切面类
@Component       // 纳入Spring容器管理
public class LoggingAspect {
    
    // 定义切入点表达式：拦截com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethods() {}
    
    // 前置通知：方法执行前打印日志
    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("【AOP】方法 " + methodName + " 开始执行，参数: " + Arrays.toString(args));
    }
    
    // 返回通知：方法正常返回后打印结果
    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【AOP】方法 " + joinPoint.getSignature().getName() + " 返回: " + result);
    }
    
    // 异常通知：方法抛出异常时记录
    @AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("【AOP】方法 " + joinPoint.getSignature().getName() + " 异常: " + ex.getMessage());
    }
}

@SpringBootTest
class AopTest {
    @Autowired
    private CalculatorService calculatorService;
    
    @Test
    void testAop() {
        calculatorService.add(10, 5);
        // 输出：
        // 【AOP】方法 add 开始执行，参数: [10, 5]
        // 【业务】加法结果: 15
        // 【AOP】方法 add 返回: 15
        
        calculatorService.div(10, 0);
        // 输出：
        // 【AOP】方法 div 开始执行，参数: [10, 0]
        // 【AOP】方法 div 异常: / by zero
        // Exception in thread "main" java.lang.ArithmeticException: / by zero
    }
}

目标类是否实现了至少一个接口？
    ├── 是 → 使用JDK动态代理
    └── 否 → 使用CGLIB动态代理

1. Spring容器启动
      ↓
2. 扫描所有@Aspect切面类，解析@Pointcut切入点表达式
      ↓
3. 遍历所有Bean，匹配切入点表达式
      ↓
4. 对于匹配的Bean，创建代理工厂（ProxyFactory）
      ↓
5. 代理工厂根据目标类特征，选择JDK或CGLIB生成代理对象
      ↓
6. 将代理对象注册到容器，替换原始Bean
      ↓
7. 运行时，调用代理对象的方法 → 触发通知链 → 执行目标方法